home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / puma.lha / puma / src / Scanner.mi < prev    next >
Text File  |  1992-09-25  |  35KB  |  1,330 lines
  1. (* $Id: Scanner.mi,v 2.10 1992/08/18 09:05:32 grosch rel grosch $ *)
  2.  
  3. IMPLEMENTATION MODULE Scanner;
  4.  
  5. IMPORT SYSTEM, Checks, System, General, Positions, IO, DynArray, Strings, Source;
  6. (* line 43 "puma.rex" *)
  7.  
  8. FROM SYSTEM    IMPORT ADR;
  9. FROM StringMem    IMPORT PutString;
  10. FROM Strings    IMPORT tString, Concatenate, Char, SubString,
  11.             AssignEmpty, Length, WriteL;
  12. FROM Idents    IMPORT tIdent, MakeIdent, NoIdent, GetStringRef;
  13. FROM Texts    IMPORT MakeText, Append;
  14. FROM Sets    IMPORT IsElement;
  15. FROM Tree    IMPORT Options, ErrorCount;
  16. FROM Positions    IMPORT tPosition;
  17.  
  18. IMPORT Errors;
  19.  
  20. VAR NestingLevel: INTEGER; Position, StringPos: tPosition;
  21.  
  22. PROCEDURE ErrorAttribute (Token: INTEGER; VAR pAttribute: tScanAttribute);
  23. BEGIN
  24.  pAttribute.Position := Attribute.Position;
  25.  CASE Token OF
  26.  | (* Ident *) 1: 
  27.  pAttribute.Ident.Ident    := NoIdent    ;
  28.  ;
  29.  | (* Operator *) 2: 
  30.  pAttribute.Operator.Ident    := NoIdent    ;
  31.  ;
  32.  | (* IncOperator *) 3: 
  33.  pAttribute.IncOperator.Ident    := NoIdent    ;
  34.  ;
  35.  | (* TargetBlock *) 4: 
  36.  MakeText (pAttribute.TargetBlock.Text); ;
  37.  ;
  38.  | (* String *) 5: 
  39.  pAttribute.String.StringRef    := GetStringRef (NoIdent);
  40.  ;
  41.  | (* Number *) 6: 
  42.  pAttribute.Number.StringRef    := GetStringRef (NoIdent);
  43.  ;
  44.  | (* TargetCode *) 7: 
  45.  pAttribute.TargetCode.StringRef    := GetStringRef (NoIdent);
  46.  ;
  47.  | (* WhiteSpace *) 8: 
  48.  pAttribute.WhiteSpace.StringRef    := GetStringRef (NoIdent);
  49.  ;
  50.  | (* '::' *) 9: 
  51.  pAttribute.yy9.StringRef    := GetStringRef (NoIdent);
  52.  ;
  53.  ELSE
  54.  END;
  55. END ErrorAttribute;
  56.  
  57.  
  58. PROCEDURE Error (Text: ARRAY OF CHAR; Position: tPosition);
  59.    BEGIN
  60.       Errors.Message (Text, Errors.Error, Position);
  61.       INC (ErrorCount);
  62.    END Error;
  63.  
  64. PROCEDURE ErrorI (Text: ARRAY OF CHAR; Position: tPosition; Ident: tIdent);
  65.    BEGIN
  66.       Errors.MessageI (Text, Errors.Error, Position, Errors.Ident, ADR (Ident));
  67.       INC (ErrorCount);
  68.    END ErrorI;
  69.  
  70. PROCEDURE Warning (Text: ARRAY OF CHAR; Position: tPosition);
  71.    BEGIN
  72.       IF NOT IsElement (ORD ('s'), Options) THEN
  73.      Errors.Message (Text, Errors.Warning, Position);
  74.       END;
  75.    END Warning;
  76.  
  77. PROCEDURE WarningI (Text: ARRAY OF CHAR; Position: tPosition; Ident: tIdent);
  78.    BEGIN
  79.       IF NOT IsElement (ORD ('s'), Options) THEN
  80.      Errors.MessageI (Text, Errors.Warning, Position, Errors.Ident, ADR (Ident));
  81.       END;
  82.    END WarningI;
  83.  
  84.  
  85. CONST
  86.    yyTabSpace        = 8;
  87.    yyDNoState        = 0;
  88.    yyFileStackSize    = 16;
  89.    yyInitBufferSize    = 1024 * 8 + 256;
  90. yyFirstCh    = 0C;
  91. yyLastCh    = 177C;
  92. yyEolCh    = 12C;
  93. yyEobCh    = 177C;
  94. yyDStateCount    = 209;
  95. yyTableSize    = 2236;
  96. yyEobState    = 65;
  97. yyDefaultState    = 66;
  98. STD    = 1;
  99. comment    = 3;
  100. Str1    = 5;
  101. Str2    = 7;
  102. CStr1    = 9;
  103. CStr2    = 11;
  104. targetcode    = 13;
  105. expr    = 15;
  106.  
  107. TYPE
  108.    yyTableElmt        = SHORTCARD;
  109.    yyStateRange        = yyTableElmt [0 .. yyDStateCount];
  110.    yyTableRange        = yyTableElmt [0 .. yyTableSize];
  111.    yyCombType        = RECORD Check, Next: yyStateRange; END;
  112.    yyCombTypePtr    = POINTER TO yyCombType;
  113.    yytChBufferPtr    = POINTER TO ARRAY [0 .. 1000000] OF CHAR;
  114.    yyChRange        = [yyFirstCh .. yyLastCh];
  115.  
  116. VAR
  117.    yyBasePtr        : ARRAY yyStateRange    OF LONGCARD    ;
  118.    yyDefault        : ARRAY yyStateRange    OF yyStateRange    ;
  119.    yyComb        : ARRAY yyTableRange    OF yyCombType    ;
  120.    yyEobTrans        : ARRAY yyStateRange    OF yyStateRange    ;
  121.    yyToLower, yyToUpper    : ARRAY yyChRange    OF CHAR        ;
  122.  
  123.    yyStateStack        : POINTER TO ARRAY [0 .. 1000000] OF yyStateRange;
  124.    yyStateStackSize    : LONGINT;
  125.    yyStartState        : yyStateRange;
  126.    yyPreviousStart    : yyStateRange;
  127.    yyCh            : CHAR;
  128.  
  129.    yySourceFile        : System.tFile;
  130.    yyEof        : BOOLEAN;
  131.    yyChBufferPtr    : yytChBufferPtr;
  132.    yyChBufferStart    : INTEGER;
  133.    yyChBufferSize    : LONGINT;
  134.    yyChBufferIndex    : INTEGER;
  135.    yyBytesRead        : INTEGER;
  136.    yyLineCount        : CARDINAL;
  137.    yyLineStart        : INTEGER;
  138.  
  139.    yyFileStackPtr    : SHORTCARD;
  140.    yyFileStack        : ARRAY [1 .. yyFileStackSize] OF RECORD
  141.                     SourceFile        : System.tFile;
  142.                  Eof        : BOOLEAN;
  143.                     ChBufferPtr    : yytChBufferPtr;
  144.                  ChBufferStart    : INTEGER;
  145.                  ChBufferSize    : LONGINT;
  146.                     ChBufferIndex    : INTEGER;
  147.                     BytesRead        : INTEGER;
  148.                     LineCount        : CARDINAL;
  149.                     LineStart        : INTEGER;
  150.               END;
  151.  
  152. PROCEDURE GetToken (): INTEGER;
  153.    VAR
  154.       yyState        : yyStateRange;
  155.       yyTablePtr    : yyCombTypePtr;
  156.       yyRestartFlag    : BOOLEAN;
  157.       yyi, yySource, yyTarget, yyChBufferFree    : INTEGER;
  158. (* line 121 "puma.rex" *)
  159.  VAR Word, String, TargetCode: tString; 
  160. BEGIN
  161.    LOOP
  162.       yyState        := yyStartState;
  163.       TokenLength     := 0;
  164.  
  165.       (* ASSERT yyChBuffer [yyChBufferIndex] = first character *)
  166.  
  167.       LOOP        (* eventually restart after sentinel *)
  168.      LOOP        (* execute as many state transitions as possible *)
  169.                             (* determine next state *)
  170.         yyTablePtr := yyCombTypePtr (yyBasePtr [yyState] +
  171.            ORD (yyChBufferPtr^ [yyChBufferIndex]) * SYSTEM.TSIZE (yyCombType));
  172.         IF yyTablePtr^.Check # yyState THEN
  173.            yyState := yyDefault [yyState];
  174.            IF yyState = yyDNoState THEN EXIT; END;
  175.         ELSE
  176.            yyState := yyTablePtr^.Next;
  177.            INC (TokenLength);
  178.            yyStateStack^ [TokenLength] := yyState;    (* push state *)
  179.            INC (yyChBufferIndex);        (* get next character *)
  180.         END;
  181.      END;
  182.  
  183.      LOOP                    (* search for last final state *)
  184. CASE yyStateStack^ [TokenLength] OF
  185. |209
  186. :
  187. Attribute.Position.Line   := yyLineCount;
  188. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  189. (* line 155 "puma.rex" *)
  190.  
  191.                IF NestingLevel = 0 THEN
  192.                   MakeText (Attribute.TargetBlock.Text);
  193.                   AssignEmpty (TargetCode);
  194.                   Position := Attribute.Position;
  195.                ELSE
  196.                   GetWord (Word);
  197.                   Concatenate (TargetCode, Word);
  198.                END;
  199.                INC (NestingLevel);
  200.             
  201. yyRestartFlag := FALSE; EXIT;
  202. |208
  203. :
  204. (* line 167 "puma.rex" *)
  205.  
  206.                DEC (NestingLevel);
  207.                IF NestingLevel = 0 THEN
  208.                   yyStart (STD);
  209.                   Append (Attribute.TargetBlock.Text, TargetCode);
  210.                   Attribute.Position := Position;
  211.                   RETURN 4;
  212.                ELSE
  213.                   GetWord (Word);
  214.                   Concatenate (TargetCode, Word);
  215.                END;
  216.             
  217. yyRestartFlag := FALSE; EXIT;
  218. |22
  219. ,75
  220. :
  221. (* line 180 "puma.rex" *)
  222.  
  223.                IF NestingLevel > 0 THEN
  224.                   GetWord (Word);
  225.                   Concatenate (TargetCode, Word);
  226.                END;
  227.             
  228. yyRestartFlag := FALSE; EXIT;
  229. |207
  230. :
  231. (* line 187 "puma.rex" *)
  232.  
  233.                IF NestingLevel > 0 THEN
  234.                   Strings.Append (TargetCode, 11C);
  235.                END;
  236.                yyTab;
  237.             
  238. yyRestartFlag := FALSE; EXIT;
  239. |206
  240. :
  241. (* line 194 "puma.rex" *)
  242.  
  243.                IF NestingLevel > 0 THEN
  244.                   Append (Attribute.TargetBlock.Text, TargetCode);
  245.                   AssignEmpty (TargetCode);
  246.                END;
  247.                yyEol (0);
  248.             
  249. yyRestartFlag := FALSE; EXIT;
  250. |23
  251. :
  252. (* line 202 "puma.rex" *)
  253.  
  254.                IF NestingLevel > 0 THEN
  255.                   GetWord (Word);
  256.                   Strings.Append (TargetCode, Char (Word, 2));
  257.                END;
  258.             
  259. yyRestartFlag := FALSE; EXIT;
  260. |37
  261. :
  262. (* line 209 "puma.rex" *)
  263.  
  264.                IF NestingLevel > 0 THEN
  265.                   Strings.Append (TargetCode, '\');
  266.                END;
  267.             
  268. yyRestartFlag := FALSE; EXIT;
  269. |203
  270. ,205
  271. :
  272. Attribute.Position.Line   := yyLineCount;
  273. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  274. (* line 215 "puma.rex" *)
  275. yyStart (comment); Position := Attribute.Position;
  276. yyRestartFlag := FALSE; EXIT;
  277. |201
  278. :
  279. (* line 216 "puma.rex" *)
  280. yyPrevious;
  281. yyRestartFlag := FALSE; EXIT;
  282. |28
  283. ,42
  284. ,70
  285. :
  286. (* line 217 "puma.rex" *)
  287.  
  288. yyRestartFlag := FALSE; EXIT;
  289. |30
  290. :
  291. (* line 219 "puma.rex" *)
  292.  
  293. yyRestartFlag := FALSE; EXIT;
  294. |29
  295. ,43
  296. ,59
  297. :
  298. Attribute.Position.Line   := yyLineCount;
  299. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  300. (* line 222 "puma.rex" *)
  301. GetWord (Word);
  302.                         Attribute.Number.StringRef := PutString (Word);
  303.                 RETURN 6;
  304. yyRestartFlag := FALSE; EXIT;
  305. |200
  306. :
  307. Attribute.Position.Line   := yyLineCount;
  308. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  309. (* line 226 "puma.rex" *)
  310. GetWord (String);
  311.                 StringPos := Attribute.Position;
  312.                 IF IsElement (ORD ('c'), Options)
  313.                 THEN yyStart (CStr1);
  314.                 ELSE yyStart (Str1);
  315.                 END;
  316. yyRestartFlag := FALSE; EXIT;
  317. |199
  318. :
  319. Attribute.Position.Line   := yyLineCount;
  320. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  321. (* line 233 "puma.rex" *)
  322. GetWord (String);
  323.                 StringPos := Attribute.Position;
  324.                 IF IsElement (ORD ('c'), Options)
  325.                 THEN yyStart (CStr2);
  326.                 ELSE yyStart (Str2);
  327.                 END;
  328. yyRestartFlag := FALSE; EXIT;
  329. |27
  330. ,71
  331. :
  332. (* line 243 "puma.rex" *)
  333. GetWord (Word); Concatenate (String, Word);
  334. yyRestartFlag := FALSE; EXIT;
  335. |26
  336. ,72
  337. :
  338. (* line 243 "puma.rex" *)
  339. GetWord (Word); Concatenate (String, Word);
  340. yyRestartFlag := FALSE; EXIT;
  341. |25
  342. ,41
  343. ,58
  344. ,73
  345. :
  346. (* line 243 "puma.rex" *)
  347. GetWord (Word); Concatenate (String, Word);
  348. yyRestartFlag := FALSE; EXIT;
  349. |24
  350. ,40
  351. ,57
  352. ,74
  353. :
  354. (* line 243 "puma.rex" *)
  355. GetWord (Word); Concatenate (String, Word);
  356. yyRestartFlag := FALSE; EXIT;
  357. |198
  358. :
  359. (* line 246 "puma.rex" *)
  360. GetWord (Word); Concatenate (String, Word); yyEol (0);
  361. yyRestartFlag := FALSE; EXIT;
  362. |197
  363. :
  364. (* line 246 "puma.rex" *)
  365. GetWord (Word); Concatenate (String, Word); yyEol (0);
  366. yyRestartFlag := FALSE; EXIT;
  367. |196
  368. :
  369. (* line 249 "puma.rex" *)
  370. Strings.Append (String, Char (String, 1));
  371.                 yyPrevious;
  372.                 IF yyStartState = targetcode THEN
  373.                    Concatenate (TargetCode, String);
  374.                 ELSE
  375.                    Attribute.String.StringRef := PutString (String);
  376.                    RETURN 5;
  377.                 END;
  378. yyRestartFlag := FALSE; EXIT;
  379. |195
  380. :
  381. (* line 249 "puma.rex" *)
  382. Strings.Append (String, Char (String, 1));
  383.                 yyPrevious;
  384.                 IF yyStartState = targetcode THEN
  385.                    Concatenate (TargetCode, String);
  386.                 ELSE
  387.                    Attribute.String.StringRef := PutString (String);
  388.                    RETURN 5;
  389.                 END;
  390. yyRestartFlag := FALSE; EXIT;
  391. |194
  392. :
  393. (* line 258 "puma.rex" *)
  394. Strings.Append (String, 11C); yyTab;
  395. yyRestartFlag := FALSE; EXIT;
  396. |193
  397. :
  398. (* line 260 "puma.rex" *)
  399. Error ("unclosed string", Attribute.Position);
  400.                 Strings.Append (String, Char (String, 1));
  401.                 yyEol (0); yyPrevious;
  402.                 IF yyStartState = targetcode THEN
  403.                    Concatenate (TargetCode, String);
  404.                 ELSE
  405.                    Attribute.String.StringRef := PutString (String);
  406.                    RETURN 5;
  407.                 END;
  408. yyRestartFlag := FALSE; EXIT;
  409. |192
  410. :
  411. Attribute.Position.Line   := yyLineCount;
  412. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  413. (* line 270 "puma.rex" *)
  414. RETURN 9            ;
  415. yyRestartFlag := FALSE; EXIT;
  416. |118
  417. :
  418. Attribute.Position.Line   := yyLineCount;
  419. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  420. (* line 272 "puma.rex" *)
  421. IF NestingLevel = 0 THEN Position := Attribute.Position; END;
  422.                yyStart (expr); INC (NestingLevel); RETURN 34;
  423. yyRestartFlag := FALSE; EXIT;
  424. |18
  425. ,35
  426. ,204
  427. :
  428. Attribute.Position.Line   := yyLineCount;
  429. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  430. (* line 275 "puma.rex" *)
  431. GetWord (Word);
  432.                Attribute.TargetCode.StringRef := PutString (Word);
  433.                RETURN 7        ;
  434. yyRestartFlag := FALSE; EXIT;
  435. |191
  436. :
  437. Attribute.Position.Line   := yyLineCount;
  438. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  439. (* line 279 "puma.rex" *)
  440. INC (NestingLevel);
  441.                GetWord (Word);
  442.                Attribute.TargetCode.StringRef := PutString (Word);
  443.                RETURN 7        ;
  444. yyRestartFlag := FALSE; EXIT;
  445. |190
  446. :
  447. Attribute.Position.Line   := yyLineCount;
  448. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  449. (* line 284 "puma.rex" *)
  450. DEC (NestingLevel);
  451.                IF NestingLevel = 0 THEN
  452.                   yyStart (STD);
  453.                   RETURN 35;
  454.                ELSE
  455.                   GetWord (Word);
  456.                   Attribute.TargetCode.StringRef := PutString (Word);
  457.                   RETURN 7;
  458.                END                ;
  459. yyRestartFlag := FALSE; EXIT;
  460. |188
  461. :
  462. Attribute.Position.Line   := yyLineCount;
  463. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  464. (* line 294 "puma.rex" *)
  465. GetWord (Word);
  466.                Attribute.TargetCode.StringRef := PutString (Word);
  467.                RETURN 7        ;
  468. yyRestartFlag := FALSE; EXIT;
  469. |189
  470. :
  471. Attribute.Position.Line   := yyLineCount;
  472. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  473. (* line 298 "puma.rex" *)
  474. GetWord (Word);
  475.                Attribute.yy9.StringRef := PutString (Word);
  476.                RETURN 9            ;
  477. yyRestartFlag := FALSE; EXIT;
  478. |19
  479. ,76
  480. :
  481. Attribute.Position.Line   := yyLineCount;
  482. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  483. (* line 302 "puma.rex" *)
  484. GetWord (Word);
  485.                Attribute.WhiteSpace.StringRef := PutString (Word);
  486.                RETURN 8        ;
  487. yyRestartFlag := FALSE; EXIT;
  488. |187
  489. :
  490. Attribute.Position.Line   := yyLineCount;
  491. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  492. (* line 306 "puma.rex" *)
  493. GetWord (Word);
  494.                Attribute.WhiteSpace.StringRef := PutString (Word);
  495.                yyEol (0);
  496.                RETURN 8        ;
  497. yyRestartFlag := FALSE; EXIT;
  498. |186
  499. :
  500. Attribute.Position.Line   := yyLineCount;
  501. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  502. (* line 311 "puma.rex" *)
  503. GetWord (Word);
  504.                Attribute.WhiteSpace.StringRef := PutString (Word);
  505.                yyTab;
  506.                RETURN 8        ;
  507. yyRestartFlag := FALSE; EXIT;
  508. |21
  509. :
  510. Attribute.Position.Line   := yyLineCount;
  511. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  512. (* line 316 "puma.rex" *)
  513. GetWord (Word);
  514.                SubString (Word, 2, 2, String);
  515.                Attribute.TargetCode.StringRef := PutString (String);
  516.                RETURN 7        ;
  517. yyRestartFlag := FALSE; EXIT;
  518. |38
  519. :
  520. Attribute.Position.Line   := yyLineCount;
  521. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  522. (* line 321 "puma.rex" *)
  523. GetWord (Word);
  524.                Attribute.TargetCode.StringRef := PutString (Word);
  525.                RETURN 7        ;
  526. yyRestartFlag := FALSE; EXIT;
  527. |150
  528. :
  529. Attribute.Position.Line   := yyLineCount;
  530. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  531. (* line 325 "puma.rex" *)
  532. yyStart (targetcode); RETURN 19    ;
  533. yyRestartFlag := FALSE; EXIT;
  534. |145
  535. :
  536. Attribute.Position.Line   := yyLineCount;
  537. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  538. (* line 326 "puma.rex" *)
  539. yyStart (targetcode); RETURN 20    ;
  540. yyRestartFlag := FALSE; EXIT;
  541. |167
  542. :
  543. Attribute.Position.Line   := yyLineCount;
  544. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  545. (* line 327 "puma.rex" *)
  546. yyStart (targetcode); RETURN 16;
  547. yyRestartFlag := FALSE; EXIT;
  548. |156
  549. :
  550. Attribute.Position.Line   := yyLineCount;
  551. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  552. (* line 328 "puma.rex" *)
  553. yyStart (targetcode); RETURN 18;
  554. yyRestartFlag := FALSE; EXIT;
  555. |161
  556. :
  557. Attribute.Position.Line   := yyLineCount;
  558. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  559. (* line 329 "puma.rex" *)
  560. yyStart (targetcode); RETURN 17;
  561. yyRestartFlag := FALSE; EXIT;
  562. |126
  563. :
  564. Attribute.Position.Line   := yyLineCount;
  565. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  566. (* line 330 "puma.rex" *)
  567. yyStart (targetcode); RETURN 30    ;
  568. yyRestartFlag := FALSE; EXIT;
  569. |31
  570. ,44
  571. ,45
  572. ,46
  573. ,47
  574. ,48
  575. ,49
  576. ,50
  577. ,60
  578. ,128
  579. ,202
  580. :
  581. Attribute.Position.Line   := yyLineCount;
  582. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  583. (* line 361 "puma.rex" *)
  584. GetWord (Word);
  585.                        Attribute.Operator.Ident := MakeIdent (Word);
  586.                RETURN 2        ;
  587. yyRestartFlag := FALSE; EXIT;
  588. |33
  589. :
  590. Attribute.Position.Line   := yyLineCount;
  591. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  592. (* line 365 "puma.rex" *)
  593. GetWord (Word);
  594.                        Attribute.IncOperator.Ident := MakeIdent (Word);
  595.                RETURN 3        ;
  596. yyRestartFlag := FALSE; EXIT;
  597. |32
  598. :
  599. Attribute.Position.Line   := yyLineCount;
  600. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  601. (* line 369 "puma.rex" *)
  602. GetWord (Word);
  603.                SubString (Word, 2, Length (Word), String);
  604.                        Attribute.Operator.Ident := MakeIdent (String);
  605.                RETURN 2        ;
  606. yyRestartFlag := FALSE; EXIT;
  607. |185
  608. :
  609. Attribute.Position.Line   := yyLineCount;
  610. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  611. (* line 374 "puma.rex" *)
  612.  RETURN 10; 
  613. yyRestartFlag := FALSE; EXIT;
  614. |182
  615. :
  616. Attribute.Position.Line   := yyLineCount;
  617. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  618. (* line 375 "puma.rex" *)
  619.  RETURN 11; 
  620. yyRestartFlag := FALSE; EXIT;
  621. |178
  622. :
  623. Attribute.Position.Line   := yyLineCount;
  624. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  625. (* line 376 "puma.rex" *)
  626.  RETURN 12; 
  627. yyRestartFlag := FALSE; EXIT;
  628. |177
  629. :
  630. Attribute.Position.Line   := yyLineCount;
  631. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  632. (* line 377 "puma.rex" *)
  633.  RETURN 13; 
  634. yyRestartFlag := FALSE; EXIT;
  635. |172
  636. :
  637. Attribute.Position.Line   := yyLineCount;
  638. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  639. (* line 378 "puma.rex" *)
  640.  RETURN 14; 
  641. yyRestartFlag := FALSE; EXIT;
  642. |168
  643. :
  644. Attribute.Position.Line   := yyLineCount;
  645. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  646. (* line 379 "puma.rex" *)
  647.  RETURN 15; 
  648. yyRestartFlag := FALSE; EXIT;
  649. |140
  650. :
  651. Attribute.Position.Line   := yyLineCount;
  652. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  653. (* line 385 "puma.rex" *)
  654.  RETURN 21; 
  655. yyRestartFlag := FALSE; EXIT;
  656. |133
  657. :
  658. Attribute.Position.Line   := yyLineCount;
  659. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  660. (* line 386 "puma.rex" *)
  661.  RETURN 22; 
  662. yyRestartFlag := FALSE; EXIT;
  663. |132
  664. :
  665. Attribute.Position.Line   := yyLineCount;
  666. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  667. (* line 387 "puma.rex" *)
  668.  RETURN 23; 
  669. yyRestartFlag := FALSE; EXIT;
  670. |77
  671. :
  672. Attribute.Position.Line   := yyLineCount;
  673. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  674. (* line 388 "puma.rex" *)
  675.  RETURN 24; 
  676. yyRestartFlag := FALSE; EXIT;
  677. |61
  678. :
  679. Attribute.Position.Line   := yyLineCount;
  680. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  681. (* line 389 "puma.rex" *)
  682.  RETURN 25; 
  683. yyRestartFlag := FALSE; EXIT;
  684. |131
  685. :
  686. Attribute.Position.Line   := yyLineCount;
  687. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  688. (* line 390 "puma.rex" *)
  689.  RETURN 26; 
  690. yyRestartFlag := FALSE; EXIT;
  691. |130
  692. :
  693. Attribute.Position.Line   := yyLineCount;
  694. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  695. (* line 391 "puma.rex" *)
  696.  RETURN 27; 
  697. yyRestartFlag := FALSE; EXIT;
  698. |129
  699. :
  700. Attribute.Position.Line   := yyLineCount;
  701. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  702. (* line 392 "puma.rex" *)
  703.  RETURN 28; 
  704. yyRestartFlag := FALSE; EXIT;
  705. |127
  706. :
  707. Attribute.Position.Line   := yyLineCount;
  708. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  709. (* line 393 "puma.rex" *)
  710.  RETURN 29; 
  711. yyRestartFlag := FALSE; EXIT;
  712. |79
  713. :
  714. Attribute.Position.Line   := yyLineCount;
  715. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  716. (* line 395 "puma.rex" *)
  717.  RETURN 31; 
  718. yyRestartFlag := FALSE; EXIT;
  719. |121
  720. :
  721. Attribute.Position.Line   := yyLineCount;
  722. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  723. (* line 396 "puma.rex" *)
  724.  RETURN 32; 
  725. yyRestartFlag := FALSE; EXIT;
  726. |119
  727. :
  728. Attribute.Position.Line   := yyLineCount;
  729. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  730. (* line 397 "puma.rex" *)
  731.  RETURN 33; 
  732. yyRestartFlag := FALSE; EXIT;
  733. |117
  734. :
  735. Attribute.Position.Line   := yyLineCount;
  736. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  737. (* line 399 "puma.rex" *)
  738.  RETURN 35; 
  739. yyRestartFlag := FALSE; EXIT;
  740. |116
  741. :
  742. Attribute.Position.Line   := yyLineCount;
  743. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  744. (* line 400 "puma.rex" *)
  745.  RETURN 36; 
  746. yyRestartFlag := FALSE; EXIT;
  747. |115
  748. :
  749. Attribute.Position.Line   := yyLineCount;
  750. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  751. (* line 401 "puma.rex" *)
  752.  RETURN 37; 
  753. yyRestartFlag := FALSE; EXIT;
  754. |114
  755. :
  756. Attribute.Position.Line   := yyLineCount;
  757. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  758. (* line 402 "puma.rex" *)
  759.  RETURN 38; 
  760. yyRestartFlag := FALSE; EXIT;
  761. |113
  762. :
  763. Attribute.Position.Line   := yyLineCount;
  764. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  765. (* line 403 "puma.rex" *)
  766.  RETURN 39; 
  767. yyRestartFlag := FALSE; EXIT;
  768. |112
  769. :
  770. Attribute.Position.Line   := yyLineCount;
  771. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  772. (* line 404 "puma.rex" *)
  773.  RETURN 40; 
  774. yyRestartFlag := FALSE; EXIT;
  775. |111
  776. :
  777. Attribute.Position.Line   := yyLineCount;
  778. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  779. (* line 405 "puma.rex" *)
  780.  RETURN 41; 
  781. yyRestartFlag := FALSE; EXIT;
  782. |107
  783. :
  784. Attribute.Position.Line   := yyLineCount;
  785. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  786. (* line 406 "puma.rex" *)
  787.  RETURN 42; 
  788. yyRestartFlag := FALSE; EXIT;
  789. |104
  790. :
  791. Attribute.Position.Line   := yyLineCount;
  792. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  793. (* line 407 "puma.rex" *)
  794.  RETURN 43; 
  795. yyRestartFlag := FALSE; EXIT;
  796. |103
  797. :
  798. Attribute.Position.Line   := yyLineCount;
  799. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  800. (* line 408 "puma.rex" *)
  801.  RETURN 44; 
  802. yyRestartFlag := FALSE; EXIT;
  803. |97
  804. :
  805. Attribute.Position.Line   := yyLineCount;
  806. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  807. (* line 409 "puma.rex" *)
  808.  RETURN 45; 
  809. yyRestartFlag := FALSE; EXIT;
  810. |89
  811. :
  812. Attribute.Position.Line   := yyLineCount;
  813. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  814. (* line 410 "puma.rex" *)
  815.  RETURN 46; 
  816. yyRestartFlag := FALSE; EXIT;
  817. |80
  818. :
  819. Attribute.Position.Line   := yyLineCount;
  820. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  821. (* line 413 "puma.rex" *)
  822. RETURN 31            ;
  823. yyRestartFlag := FALSE; EXIT;
  824. |78
  825. :
  826. Attribute.Position.Line   := yyLineCount;
  827. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  828. (* line 414 "puma.rex" *)
  829. RETURN 40            ;
  830. yyRestartFlag := FALSE; EXIT;
  831. |17
  832. ,34
  833. ,51
  834. ,52
  835. ,53
  836. ,54
  837. ,55
  838. ,56
  839. ,62
  840. ,63
  841. ,81
  842. ,82
  843. ,83
  844. ,84
  845. ,85
  846. ,86
  847. ,87
  848. ,88
  849. ,90
  850. ,91
  851. ,92
  852. ,93
  853. ,94
  854. ,95
  855. ,96
  856. ,98
  857. ,99
  858. ,100
  859. ,101
  860. ,102
  861. ,105
  862. ,106
  863. ,108
  864. ,109
  865. ,110
  866. ,120
  867. ,122
  868. ,123
  869. ,124
  870. ,125
  871. ,134
  872. ,135
  873. ,136
  874. ,137
  875. ,138
  876. ,139
  877. ,141
  878. ,142
  879. ,143
  880. ,144
  881. ,146
  882. ,147
  883. ,148
  884. ,149
  885. ,151
  886. ,152
  887. ,153
  888. ,154
  889. ,155
  890. ,157
  891. ,158
  892. ,159
  893. ,160
  894. ,162
  895. ,163
  896. ,164
  897. ,165
  898. ,166
  899. ,169
  900. ,170
  901. ,171
  902. ,173
  903. ,174
  904. ,175
  905. ,176
  906. ,179
  907. ,180
  908. ,181
  909. ,183
  910. ,184
  911. :
  912. Attribute.Position.Line   := yyLineCount;
  913. Attribute.Position.Column := yyChBufferIndex - yyLineStart - TokenLength;
  914. (* line 417 "puma.rex" *)
  915. GetWord (Word);
  916.                        Attribute.Ident.Ident := MakeIdent (Word);
  917.                RETURN 1            ;
  918. yyRestartFlag := FALSE; EXIT;
  919. |69
  920. :
  921. (* BlankAction *)
  922. WHILE yyChBufferPtr^ [yyChBufferIndex] = ' ' DO INC (yyChBufferIndex); END;
  923. yyRestartFlag := FALSE; EXIT;
  924. |68
  925. :
  926. (* TabAction *)
  927. DEC (yyLineStart, 7 - (yyChBufferIndex - yyLineStart - 2) MOD 8);
  928. yyRestartFlag := FALSE; EXIT;
  929. |67
  930. :
  931. (* EolAction *)
  932. INC (yyLineCount);
  933. yyLineStart := yyChBufferIndex - 1;
  934. yyRestartFlag := FALSE; EXIT;
  935. |1
  936. ,2
  937. ,3
  938. ,4
  939. ,5
  940. ,6
  941. ,7
  942. ,8
  943. ,9
  944. ,10
  945. ,11
  946. ,12
  947. ,13
  948. ,14
  949. ,15
  950. ,16
  951. ,20
  952. ,36
  953. ,39
  954. ,64
  955. :
  956.         (* non final states *)
  957.           DEC (yyChBufferIndex);    (* return character *)
  958.           DEC (TokenLength)        (* pop state *)
  959.  
  960. | 66:
  961.           Attribute.Position.Line   := yyLineCount;
  962.           Attribute.Position.Column := yyChBufferIndex - yyLineStart;
  963.           INC (yyChBufferIndex);
  964.           TokenLength := 1;
  965. (* line 125 "puma.rex" *)
  966.  
  967.    GetWord (Word);
  968.    Errors.MessageI ("illegal character", Errors.Error, Attribute.Position, Errors.String, ADR (Word));
  969.  
  970.               yyRestartFlag := FALSE; EXIT;
  971.  
  972.         |  yyDNoState    :        (* automatic initialization *)
  973.           yyGetTables;
  974.           yyStateStack^ [0] := yyDefaultState; (* stack underflow sentinel *)
  975.           IF yyFileStackPtr = 0 THEN
  976.              yyInitialize;
  977.              yySourceFile := System.StdInput;
  978.           END;
  979.               yyRestartFlag := FALSE; EXIT;
  980.  
  981. | 65:
  982.           DEC (yyChBufferIndex);    (* undo last state transition *)
  983.           DEC (TokenLength);        (* get previous state *)
  984.           IF TokenLength = 0 THEN
  985.              yyState := yyStartState;
  986.           ELSE
  987.              yyState := yyStateStack^ [TokenLength];
  988.           END;
  989.  
  990.           IF yyChBufferIndex # yyChBufferStart + yyBytesRead THEN
  991.              yyState := yyEobTrans [yyState];    (* end of buffer sentinel in buffer *)
  992.              IF yyState # yyDNoState THEN
  993.             INC (yyChBufferIndex);
  994.             INC (TokenLength);
  995.             yyStateStack^ [TokenLength] := yyState;
  996.             yyRestartFlag := TRUE; EXIT;
  997.              END;
  998.           ELSE                (* end of buffer reached *)
  999.  
  1000.              (* copy initial part of token in front of input buffer *)
  1001.  
  1002.              yySource := yyChBufferIndex - TokenLength - 1;
  1003.              yyTarget := General.MaxAlign - TokenLength MOD General.MaxAlign - 1;
  1004.              IF yySource # yyTarget THEN
  1005.             FOR yyi := 1 TO TokenLength DO
  1006.                yyChBufferPtr^ [yyTarget + yyi] := yyChBufferPtr^ [yySource + yyi];
  1007.             END;
  1008.             DEC (yyLineStart, yySource - yyTarget);
  1009.             yyChBufferStart := yyTarget + TokenLength + 1;
  1010.              ELSE
  1011.             yyChBufferStart := yyChBufferIndex;
  1012.              END;
  1013.  
  1014.              IF NOT yyEof THEN        (* read buffer and restart *)
  1015.             yyChBufferFree := General.Exp2 (General.Log2 (yyChBufferSize - 4 - General.MaxAlign - TokenLength));
  1016.             IF yyChBufferFree < yyChBufferSize DIV 8 THEN
  1017.                DynArray.ExtendArray (yyChBufferPtr, yyChBufferSize, SYSTEM.TSIZE (CHAR));
  1018.                IF yyChBufferPtr = NIL THEN yyErrorMessage (1); END;
  1019.                yyChBufferFree := General.Exp2 (General.Log2 (yyChBufferSize - 4 - General.MaxAlign - TokenLength));
  1020.                IF yyStateStackSize < yyChBufferSize THEN
  1021.                   DynArray.ExtendArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  1022.                   IF yyStateStack = NIL THEN yyErrorMessage (1); END;
  1023.                END;
  1024.             END;
  1025.             yyChBufferIndex := yyChBufferStart;
  1026.             yyBytesRead := Source.GetLine (yySourceFile, SYSTEM.ADR
  1027.                (yyChBufferPtr^ [yyChBufferIndex]), yyChBufferFree);
  1028.             IF yyBytesRead <= 0 THEN yyBytesRead := 0; yyEof := TRUE; END;
  1029.             yyChBufferPtr^ [yyChBufferStart + yyBytesRead    ] := yyEobCh;
  1030.             yyChBufferPtr^ [yyChBufferStart + yyBytesRead + 1] := 0C;
  1031.             yyRestartFlag := TRUE; EXIT;
  1032.              END;
  1033.  
  1034.              IF TokenLength = 0 THEN    (* end of file reached *)
  1035.             Attribute.Position.Line   := yyLineCount;
  1036.             Attribute.Position.Column := yyChBufferIndex - yyLineStart;
  1037.             CloseFile;
  1038.             IF yyFileStackPtr = 0 THEN
  1039. (* line 130 "puma.rex" *)
  1040.  
  1041.    CASE yyStartState OF
  1042.    | comment    : Error ("unclosed comment", Position);
  1043.    | expr    ,
  1044.      targetcode    : Error ("unclosed target code", Position);
  1045.    | CStr1, CStr2,
  1046.      Str1, Str2    : Error ("unclosed string", StringPos);
  1047.    ELSE
  1048.    END;
  1049.  
  1050.             END;
  1051.             IF yyFileStackPtr = 0 THEN RETURN EofToken; END;
  1052.             yyRestartFlag := FALSE; EXIT;
  1053.              END;
  1054.           END;
  1055.         ELSE
  1056.            yyErrorMessage (0);
  1057.         END;
  1058.      END;
  1059.      IF yyRestartFlag THEN ELSE EXIT; END;
  1060.       END;
  1061.    END;
  1062.    END GetToken;
  1063.  
  1064. PROCEDURE BeginFile (FileName: ARRAY OF CHAR);
  1065.    BEGIN
  1066.       IF yyStateStack^ [0] = yyDNoState THEN    (* have tables been read in ? *)
  1067.      yyGetTables;
  1068.      yyStateStack^ [0] := yyDefaultState;    (* stack underflow sentinel *)
  1069.       END;
  1070.       yyInitialize;
  1071.       yySourceFile := Source.BeginSource (FileName);
  1072.       IF yySourceFile < 0 THEN yyErrorMessage (5); END;
  1073.    END BeginFile;
  1074.  
  1075. PROCEDURE yyInitialize;
  1076.    BEGIN
  1077.       IF yyFileStackPtr >= yyFileStackSize THEN yyErrorMessage (3); END;
  1078.       INC (yyFileStackPtr);            (* push file *)
  1079.       WITH yyFileStack [yyFileStackPtr] DO
  1080.      SourceFile    := yySourceFile        ;
  1081.      Eof        := yyEof        ;
  1082.      ChBufferPtr    := yyChBufferPtr    ;
  1083.      ChBufferStart    := yyChBufferStart    ;
  1084.      ChBufferSize    := yyChBufferSize    ;
  1085.      ChBufferIndex    := yyChBufferIndex    ;
  1086.      BytesRead    := yyBytesRead        ;
  1087.      LineCount    := yyLineCount        ;
  1088.      LineStart    := yyLineStart        ;
  1089.       END;
  1090.                         (* initialize file state *)
  1091.       yyChBufferSize    := yyInitBufferSize;
  1092.       DynArray.MakeArray (yyChBufferPtr, yyChBufferSize, SYSTEM.TSIZE (CHAR));
  1093.       IF yyChBufferPtr = NIL THEN yyErrorMessage (1); END;
  1094.       yyChBufferStart    := General.MaxAlign;
  1095.       yyChBufferPtr^ [yyChBufferStart - 1] := yyEolCh; (* begin of line indicator *)
  1096.       yyChBufferPtr^ [yyChBufferStart    ] := yyEobCh; (* end of buffer sentinel *)
  1097.       yyChBufferPtr^ [yyChBufferStart + 1] := 0C;
  1098.       yyChBufferIndex    := yyChBufferStart;
  1099.       yyEof        := FALSE;
  1100.       yyBytesRead    := 0;
  1101.       yyLineCount    := 1;
  1102.       yyLineStart    := yyChBufferStart - 1;
  1103.    END yyInitialize;
  1104.  
  1105. PROCEDURE CloseFile;
  1106.    BEGIN
  1107.       IF yyFileStackPtr = 0 THEN yyErrorMessage (4); END;
  1108.       Source.CloseSource (yySourceFile);
  1109.       DynArray.ReleaseArray (yyChBufferPtr, yyChBufferSize, SYSTEM.TSIZE (CHAR));
  1110.       WITH yyFileStack [yyFileStackPtr] DO    (* pop file *)
  1111.      yySourceFile    := SourceFile        ;
  1112.      yyEof        := Eof            ;
  1113.      yyChBufferPtr    := ChBufferPtr        ;
  1114.      yyChBufferStart:= ChBufferStart    ;
  1115.      yyChBufferSize    := ChBufferSize        ;
  1116.      yyChBufferIndex:= ChBufferIndex    ;
  1117.      yyBytesRead    := BytesRead        ;
  1118.      yyLineCount    := LineCount        ;
  1119.      yyLineStart    := LineStart        ;
  1120.       END;
  1121.       DEC (yyFileStackPtr);        
  1122.    END CloseFile;
  1123.  
  1124. PROCEDURE GetWord (VAR Word: Strings.tString);
  1125.    VAR i, WordStart    : INTEGER;
  1126.    BEGIN
  1127.       WordStart := yyChBufferIndex - TokenLength - 1;
  1128.       FOR i := 1 TO TokenLength DO
  1129.      Word.Chars [i] := yyChBufferPtr^ [WordStart + i];
  1130.       END;
  1131.       Word.Length := TokenLength;
  1132.    END GetWord;
  1133.  
  1134. PROCEDURE GetLower (VAR Word: Strings.tString);
  1135.    VAR i, WordStart    : INTEGER;
  1136.    BEGIN
  1137.       WordStart := yyChBufferIndex - TokenLength - 1;
  1138.       FOR i := 1 TO TokenLength DO
  1139.      Word.Chars [i] := yyToLower [yyChBufferPtr^ [WordStart + i]];
  1140.       END;
  1141.       Word.Length := TokenLength;
  1142.    END GetLower;
  1143.  
  1144. PROCEDURE GetUpper (VAR Word: Strings.tString);
  1145.    VAR i, WordStart    : INTEGER;
  1146.    BEGIN
  1147.       WordStart := yyChBufferIndex - TokenLength - 1;
  1148.       FOR i := 1 TO TokenLength DO
  1149.      Word.Chars [i] := yyToUpper [yyChBufferPtr^ [WordStart + i]];
  1150.       END;
  1151.       Word.Length := TokenLength;
  1152.    END GetUpper;
  1153.  
  1154. PROCEDURE yyStart (State: yyStateRange);
  1155.    BEGIN
  1156.       yyPreviousStart    := yyStartState;
  1157.       yyStartState    := State;
  1158.    END yyStart;
  1159.  
  1160. PROCEDURE yyPrevious;
  1161.    VAR s    : yyStateRange;
  1162.    BEGIN
  1163.       s              := yyStartState;
  1164.       yyStartState    := yyPreviousStart;
  1165.       yyPreviousStart := s;
  1166.    END yyPrevious;
  1167.  
  1168. PROCEDURE yyEcho;
  1169.    VAR i    : INTEGER;
  1170.    BEGIN
  1171.       FOR i := yyChBufferIndex - TokenLength TO yyChBufferIndex - 1 DO
  1172.      IO.WriteC (IO.StdOutput, yyChBufferPtr^ [i]);
  1173.       END;
  1174.    END yyEcho;
  1175.  
  1176. PROCEDURE yyLess (n: INTEGER);
  1177.    BEGIN
  1178.       DEC (yyChBufferIndex, TokenLength - n);
  1179.       TokenLength := n;
  1180.    END yyLess;
  1181.  
  1182. PROCEDURE yyTab;
  1183.    BEGIN
  1184.       DEC (yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - 2) MOD yyTabSpace);
  1185.    END yyTab;
  1186.  
  1187. PROCEDURE yyTab1 (a: INTEGER);
  1188.    BEGIN
  1189.       DEC (yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - TokenLength + a - 1) MOD yyTabSpace);
  1190.    END yyTab1;
  1191.  
  1192. PROCEDURE yyTab2 (a, b: INTEGER);
  1193.    BEGIN
  1194.       DEC (yyLineStart, yyTabSpace - 1 - (yyChBufferIndex - yyLineStart - TokenLength + a - 1) MOD yyTabSpace);
  1195.    END yyTab2;
  1196.  
  1197. PROCEDURE yyEol (Column: INTEGER);
  1198.    BEGIN
  1199.       INC (yyLineCount);
  1200.       yyLineStart := yyChBufferIndex - 1 - Column;
  1201.    END yyEol;
  1202.  
  1203. PROCEDURE output (c: CHAR);
  1204.    BEGIN
  1205.       IO.WriteC (IO.StdOutput, c);
  1206.    END output;
  1207.  
  1208. PROCEDURE unput (c: CHAR);
  1209.    BEGIN
  1210.       DEC (yyChBufferIndex);
  1211.       yyChBufferPtr^ [yyChBufferIndex] := c;
  1212.    END unput;
  1213.  
  1214. PROCEDURE input (): CHAR;
  1215.    BEGIN
  1216.       IF yyChBufferIndex = yyChBufferStart + yyBytesRead THEN
  1217.      IF NOT yyEof THEN
  1218.         DEC (yyLineStart, yyBytesRead);
  1219.         yyChBufferIndex := 0;
  1220.         yyChBufferStart := 0;
  1221.         yyBytesRead := Source.GetLine (yySourceFile, yyChBufferPtr, General.Exp2 (General.Log2 (yyChBufferSize)));
  1222.         IF yyBytesRead <= 0 THEN yyBytesRead := 0; yyEof := TRUE; END;
  1223.         yyChBufferPtr^ [yyBytesRead    ] := yyEobCh;
  1224.         yyChBufferPtr^ [yyBytesRead + 1] := 0C;
  1225.      END;
  1226.       END;
  1227.       IF yyChBufferIndex = yyChBufferStart + yyBytesRead THEN
  1228.      RETURN 0C;
  1229.       ELSE
  1230.      INC (yyChBufferIndex);
  1231.      RETURN yyChBufferPtr^ [yyChBufferIndex - 1];
  1232.       END
  1233.    END input;
  1234.  
  1235. PROCEDURE BeginScanner;
  1236.    BEGIN
  1237. (* line 123 "puma.rex" *)
  1238.  NestingLevel := 0; 
  1239.    END BeginScanner;
  1240.  
  1241. PROCEDURE CloseScanner;
  1242.    BEGIN
  1243.    END CloseScanner;
  1244.  
  1245. PROCEDURE yyGetTables;
  1246.    VAR
  1247.       BlockSize, j, n    : CARDINAL;
  1248.       TableFile    : System.tFile;
  1249.       i        : yyStateRange;
  1250.       Base    : ARRAY yyStateRange OF yyTableRange;
  1251.    BEGIN
  1252.       BlockSize    := 64000 DIV SYSTEM.TSIZE (yyCombType);
  1253.       TableFile := System.OpenInput (ScanTabName);
  1254.       Checks.ErrorCheck ("yyGetTables.OpenInput", TableFile);
  1255.       IF (yyGetTable (TableFile, SYSTEM.ADR (Base      )) DIV SYSTEM.TSIZE (yyTableElmt) - 1 # yyDStateCount) OR
  1256.          (yyGetTable (TableFile, SYSTEM.ADR (yyDefault )) DIV SYSTEM.TSIZE (yyTableElmt) - 1 # yyDStateCount) OR
  1257.          (yyGetTable (TableFile, SYSTEM.ADR (yyEobTrans)) DIV SYSTEM.TSIZE (yyTableElmt) - 1 # yyDStateCount)
  1258.      THEN
  1259.      yyErrorMessage (2);
  1260.       END;
  1261.       n := 0;
  1262.       j := 0;
  1263.       WHILE j <= yyTableSize DO
  1264.          INC (n, yyGetTable (TableFile, SYSTEM.ADR (yyComb [j])) DIV SYSTEM.TSIZE (yyCombType));
  1265.          INC (j, BlockSize);
  1266.       END;
  1267.       IF n # yyTableSize + 1 THEN yyErrorMessage (2); END;
  1268.       System.Close (TableFile);
  1269.  
  1270.       FOR i := 0 TO yyDStateCount DO
  1271.      yyBasePtr [i] := LONGCARD (SYSTEM.ADR (yyComb [Base [i]]));
  1272.       END;
  1273.    END yyGetTables;
  1274.  
  1275. PROCEDURE yyGetTable (TableFile: System.tFile; Address: SYSTEM.ADDRESS): CARDINAL;
  1276.    VAR
  1277.       N        : INTEGER;
  1278.       Length    : yyTableElmt;
  1279.    BEGIN
  1280.       N := System.Read (TableFile, SYSTEM.ADR (Length), SYSTEM.TSIZE (yyTableElmt));
  1281.       Checks.ErrorCheck ("yyGetTable.Read1", N);
  1282.       N := System.Read (TableFile, Address, Length);
  1283.       Checks.ErrorCheck ("yyGetTable.Read2", N);
  1284.       RETURN Length;
  1285.    END yyGetTable;
  1286.  
  1287. PROCEDURE yyErrorMessage (ErrorCode: SHORTCARD);
  1288.    BEGIN
  1289.       Positions.WritePosition (IO.StdError, Attribute.Position);
  1290.       CASE ErrorCode OF
  1291.    | 0: IO.WriteS (IO.StdError, ": Scanner: internal error");
  1292.    | 1: IO.WriteS (IO.StdError, ": Scanner: out of memory");
  1293.    | 2: IO.WriteS (IO.StdError, ": Scanner: table mismatch");
  1294.    | 3: IO.WriteS (IO.StdError, ": Scanner: too many nested include files");
  1295.    | 4: IO.WriteS (IO.StdError, ": Scanner: file stack underflow (too many calls of CloseFile)");
  1296.    | 5: IO.WriteS (IO.StdError, ": Scanner: cannot open input file");
  1297.       END;
  1298.       IO.WriteNl (IO.StdError); Exit;
  1299.    END yyErrorMessage;
  1300.  
  1301. PROCEDURE yyExit;
  1302.    BEGIN
  1303.       IO.CloseIO; System.Exit (1);
  1304.    END yyExit;
  1305.  
  1306. BEGIN
  1307.    ScanTabName        := "Scanner.Tab";
  1308.    Exit            := yyExit;
  1309.    yyFileStackPtr    := 0;
  1310.    yyStartState        := 1;            (* set up for auto init *)
  1311.    yyPreviousStart    := 1;
  1312.    yyBasePtr [yyStartState] := LONGCARD (SYSTEM.ADR (yyComb [0]));
  1313.    yyDefault [yyStartState] := yyDNoState;
  1314.    yyComb [0].Check    := yyDNoState;
  1315.    yyChBufferPtr    := SYSTEM.ADR (yyComb [0]);    (* dirty trick *)
  1316.    yyChBufferIndex    := 1;                (* dirty trick *)
  1317.    yyStateStackSize    := yyInitBufferSize;
  1318.    DynArray.MakeArray (yyStateStack, yyStateStackSize, SYSTEM.TSIZE (yyStateRange));
  1319.    yyStateStack^ [0]    := yyDNoState;
  1320.    
  1321.    FOR yyCh := yyFirstCh TO yyLastCh DO yyToLower [yyCh] := yyCh; END;
  1322.    yyToUpper := yyToLower;
  1323.    FOR yyCh := 'A' TO 'Z' DO
  1324.       yyToLower [yyCh] := CHR (ORD (yyCh) - ORD ('A') + ORD ('a'));
  1325.    END;
  1326.    FOR yyCh := 'a' TO 'z' DO
  1327.       yyToUpper [yyCh] := CHR (ORD (yyCh) - ORD ('a') + ORD ('A'));
  1328.    END;
  1329. END Scanner.
  1330.